// 导入新的组件配置
import { componentConfigs } from './component-configs/index'

/**
 * 组件配置类型定义
 * @typedef {Object} ComponentConfig
 * @property {string} name - 组件名称
 * @property {string} [description] - 组件描述
 * @property {Object.<string, PropConfig>} props - 组件属性配置
 * @property {Object.<string, string>} events - 组件事件配置，键为事件名，值为描述
 * @property {Object.<string, string>} slots - 组件插槽配置，键为插槽名，值为描述
 * @property {Array<ComponentConfig>} [childComponents] - 子组件配置
 * @property {boolean} [canBeSlotContent=true] - 是否可作为插槽内容
 * @property {string} [category] - 组件分类
 * @property {string} [icon] - 组件图标
 */

/**
 * 属性类型枚举
 * @typedef {'string'|'number'|'boolean'|'select'|'icon-select'|'color'|'date'|'json'} PropType
 */

/**
 * 编辑器配置类型定义
 * @typedef {Object} EditorProps
 * @property {string} [placeholder] - 编辑器占位文本
 * @property {Array<{value: *, label: string}>} [options] - 选择型属性的选项
 * @property {number} [min] - 最小值(数字类型)
 * @property {number} [max] - 最大值(数字类型)
 * @property {number} [step] - 步长(数字类型)
 * @property {boolean} [multiple] - 是否多选(选择类型)
 * @property {string} [component] - 自定义编辑器组件
 * @property {Object} [props] - 自定义编辑器组件的props
 */

/**
 * 属性配置类型定义
 * @typedef {Object} PropConfig
 * @property {PropType} type - 属性类型
 * @property {string} [label] - 属性显示名称
 * @property {string} [description] - 属性描述
 * @property {*} [default] - 默认值
 * @property {boolean} [required=false] - 是否必填
 * @property {boolean} [group=false] - 是否为分组属性
 * @property {Object.<string, PropConfig>} [props] - 分组属性下的子属性
 * @property {EditorProps} [editorProps] - 属性编辑器配置
 * @property {function(*): boolean} [validator] - 自定义验证函数
 * @property {Array<{when: function(Object): boolean, then: PropConfig}>} [conditionalProps] - 条件属性配置
 */

/**
 * 支持的属性类型列表
 * @type {Array<PropType>}
 */
const SUPPORTED_PROP_TYPES = [
  'string', 'number', 'boolean', 'select', 
  'icon-select', 'color', 'date', 'json'
];

/**
 * 验证组件配置
 * @param {ComponentConfig} config - 组件配置对象
 * @throws {Error} 如果配置无效则抛出错误
 */
function validateConfig(config) {
  if (!config) {
    throw new Error('组件配置不能为空');
  }
  if (typeof config !== 'object') {
    throw new Error('组件配置必须是对象');
  }
  
  // 验证基础字段
  if (!config.name) {
    throw new Error('组件配置缺少name字段');
  }

  // 验证props结构
  if (config.props) {
    for (const [key, prop] of Object.entries(config.props)) {
      if (!prop.type) {
        throw new Error(`属性 ${key} 缺少type定义`);
      }
      
      // 验证属性类型是否受支持
      if (!SUPPORTED_PROP_TYPES.includes(prop.type)) {
        throw new Error(`属性 ${key} 的类型 ${prop.type} 不受支持`);
      }

      // 验证自定义验证器
      if (prop.validator && typeof prop.validator !== 'function') {
        throw new Error(`属性 ${key} 的validator必须是函数`);
      }

      // 验证分组属性
      if (prop.group && !prop.props) {
        throw new Error(`分组属性 ${key} 缺少props定义`);
      }

      // 递归验证子属性
      if (prop.props) {
        validateConfig({ props: prop.props });
      }
    }
  }
}

/**
 * 智能推断属性类型
 * @param {*} value 
 * @returns {PropType}
 */
function inferPropType(value) {
  if (value === null || value === undefined) return 'string';
  if (Array.isArray(value)) return 'select';
  switch (typeof value) {
    case 'string': return 'string';
    case 'number': return 'number';
    case 'boolean': return 'boolean';
    case 'object': return 'json';
    default: return 'string';
  }
}

/**
 * 简化属性配置
 * @param {string|Object} config 
 * @returns {PropConfig}
 */
export function createProp(config) {
  if (typeof config === 'string') {
    return {
      type: inferPropType(config),
      description: config
    };
  }
  return {
    type: config.type || inferPropType(config.default),
    ...config
  };
}

/**
 * 获取经过验证的组件配置
 * @param {string} componentName - 组件名称
 * @returns {ComponentConfig}
 */
export function getComponentConfig(componentName) {
  const config = componentConfigs.find(c => c.name === componentName);
  if (!config) {
    console.error(`找不到组件配置: ${componentName}`);
    return null;
  }
  
  try {
    validateConfig(config);
    return config;
  } catch (error) {
    console.error(`组件 ${componentName} 配置验证失败:\n${error.message}\n请检查以下字段:\n${Object.keys(config).join('\n')}`);
    return null;
  }
}

/**
 * 获取组件分类列表
 * @returns {Array<string>}
 */
export function getComponentCategories() {
  return [...new Set(componentConfigs.map(c => c.category || 'default'))];
}

// 导入文档生成器
import { generateComponentDocs, generateAllDocs } from './component-configs/utils/generate-docs';

// 导出原始配置和增强方法
export { 
  componentConfigs,
  validateConfig,
  generateComponentDocs,
  generateAllDocs
}